package com.gitee.qdbp.general.common.api.reusable.model;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import com.gitee.qdbp.general.common.enums.ProcessType;

/**
 * 处理过程备注查询类
 *
 * @author zhh
 * @version 180514
 */
public class ProcessingRecordWhere extends ProcessingRecordBean {

    /** 版本序列号 **/
    private static final long serialVersionUID = 1L;

    /** 过程ID列表 **/
    private List<String> ids;

    /** 过程ID前模匹配条件 **/
    private String idStarts;

    /** 过程ID后模匹配条件 **/
    private String idEnds;

    /** 过程ID模糊查询条件 **/
    private String idLike;

    /** 租户编号空值/非空值查询 **/
    private Boolean tenantCodeIsNull;

    /** 租户编号前模匹配条件 **/
    private String tenantCodeStarts;

    /** 租户编号后模匹配条件 **/
    private String tenantCodeEnds;

    /** 租户编号模糊查询条件 **/
    private String tenantCodeLike;

    /** 数据类型空值/非空值查询 **/
    private Boolean dataTypeIsNull;

    /** 数据类型前模匹配条件 **/
    private String dataTypeStarts;

    /** 数据类型后模匹配条件 **/
    private String dataTypeEnds;

    /** 数据类型模糊查询条件 **/
    private String dataTypeLike;

    /** 数据ID空值/非空值查询 **/
    private Boolean dataIdIsNull;

    /** 数据ID前模匹配条件 **/
    private String dataIdStarts;

    /** 数据ID后模匹配条件 **/
    private String dataIdEnds;

    /** 数据ID模糊查询条件 **/
    private String dataIdLike;

    /** 数据描述空值/非空值查询 **/
    private Boolean dataDescIsNull;

    /** 数据描述前模匹配条件 **/
    private String dataDescStarts;

    /** 数据描述后模匹配条件 **/
    private String dataDescEnds;

    /** 数据描述模糊查询条件 **/
    private String dataDescLike;

    /** 业务类型空值/非空值查询 **/
    private Boolean bizTypeIsNull;

    /** 业务类型前模匹配条件 **/
    private String bizTypeStarts;

    /** 业务类型后模匹配条件 **/
    private String bizTypeEnds;

    /** 业务类型模糊查询条件 **/
    private String bizTypeLike;

    /** 业务编号空值/非空值查询 **/
    private Boolean bizCodeIsNull;

    /** 业务编号前模匹配条件 **/
    private String bizCodeStarts;

    /** 业务编号后模匹配条件 **/
    private String bizCodeEnds;

    /** 业务编号模糊查询条件 **/
    private String bizCodeLike;

    /** 可见级别:1.用户可见|2.管理员可见|3.高管可见空值/非空值查询 **/
    private Boolean visibleLevelIsNull;

    /** 最小可见级别:1.用户可见|2.管理员可见|3.高管可见 **/
    private Integer visibleLevelMin;

    /** 最大可见级别:1.用户可见|2.管理员可见|3.高管可见 **/
    private Integer visibleLevelMax;

    /** 处理类型(0.处理|1.备注|2.结论)空值/非空值查询 **/
    private Boolean processTypeIsNull;

    /** 处理类型(0.处理|1.备注|2.结论)列表 **/
    private List<ProcessType> processTypes;

    /** 处理标题空值/非空值查询 **/
    private Boolean processTitleIsNull;

    /** 处理标题前模匹配条件 **/
    private String processTitleStarts;

    /** 处理标题后模匹配条件 **/
    private String processTitleEnds;

    /** 处理标题模糊查询条件 **/
    private String processTitleLike;

    /** 处理描述空值/非空值查询 **/
    private Boolean processContentIsNull;

    /** 处理描述前模匹配条件 **/
    private String processContentStarts;

    /** 处理描述后模匹配条件 **/
    private String processContentEnds;

    /** 处理描述模糊查询条件 **/
    private String processContentLike;

    /** 处理状态(文字)空值/非空值查询 **/
    private Boolean processStateIsNull;

    /** 处理状态(文字)前模匹配条件 **/
    private String processStateStarts;

    /** 处理状态(文字)后模匹配条件 **/
    private String processStateEnds;

    /** 处理状态(文字)模糊查询条件 **/
    private String processStateLike;

    /** 处理人id空值/非空值查询 **/
    private Boolean processorIdIsNull;

    /** 处理人id前模匹配条件 **/
    private String processorIdStarts;

    /** 处理人id后模匹配条件 **/
    private String processorIdEnds;

    /** 处理人id模糊查询条件 **/
    private String processorIdLike;

    /** 处理人姓名空值/非空值查询 **/
    private Boolean processorNameIsNull;

    /** 处理人姓名前模匹配条件 **/
    private String processorNameStarts;

    /** 处理人姓名后模匹配条件 **/
    private String processorNameEnds;

    /** 处理人姓名模糊查询条件 **/
    private String processorNameLike;

    /** 处理时间空值/非空值查询 **/
    private Boolean processTimeIsNull;

    /** 最小处理时间 **/
    private Date processTimeMin;

    /** 最大处理时间 **/
    private Date processTimeMax;

    /** 最小处理时间 **/
    private Date processTimeMinWithDay;

    /** 最大处理时间 **/
    private Date processTimeMaxWithDay;

    /** 查询字符串空值/非空值查询 **/
    private Boolean queryStringIsNull;

    /** 查询字符串前模匹配条件 **/
    private String queryStringStarts;

    /** 查询字符串后模匹配条件 **/
    private String queryStringEnds;

    /** 查询字符串模糊查询条件 **/
    private String queryStringLike;

    /** 选项空值/非空值查询 **/
    private Boolean optionsIsNull;

    /** 获取过程ID列表 **/
    public List<String> getIds() {
        return ids;
    }

    /** 设置过程ID列表 **/
    public void setIds(List<String> ids) {
        this.ids = ids;
    }

    /** 增加过程ID **/
    public void addId(String... ids) {
        if (this.ids == null) {
            this.ids = new ArrayList<>();
        }
        this.ids.addAll(Arrays.asList(ids));
    }

    /** 获取过程ID前模匹配条件 **/
    public String getIdStarts() {
        return idStarts;
    }

    /** 设置过程ID前模匹配条件 **/
    public void setIdStarts(String idStarts) {
        this.idStarts = idStarts;
    }

    /** 获取过程ID后模匹配条件 **/
    public String getIdEnds() {
        return idEnds;
    }

    /** 设置过程ID后模匹配条件 **/
    public void setIdEnds(String idEnds) {
        this.idEnds = idEnds;
    }

    /** 获取过程ID模糊查询条件 **/
    public String getIdLike() {
        return idLike;
    }

    /** 设置过程ID模糊查询条件 **/
    public void setIdLike(String idLike) {
        this.idLike = idLike;
    }

    /** 判断租户编号是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getTenantCodeIsNull() {
        return tenantCodeIsNull;
    }

    /**
     * 设置租户编号空值查询(true:空值查询|false:非空值查询)
     *
     * @param tenantCodeIsNull 租户编号空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setTenantCodeIsNull(Boolean tenantCodeIsNull) {
        this.tenantCodeIsNull = tenantCodeIsNull;
    }

    /** 获取租户编号前模匹配条件 **/
    public String getTenantCodeStarts() {
        return tenantCodeStarts;
    }

    /** 设置租户编号前模匹配条件 **/
    public void setTenantCodeStarts(String tenantCodeStarts) {
        this.tenantCodeStarts = tenantCodeStarts;
    }

    /** 获取租户编号后模匹配条件 **/
    public String getTenantCodeEnds() {
        return tenantCodeEnds;
    }

    /** 设置租户编号后模匹配条件 **/
    public void setTenantCodeEnds(String tenantCodeEnds) {
        this.tenantCodeEnds = tenantCodeEnds;
    }

    /** 获取租户编号模糊查询条件 **/
    public String getTenantCodeLike() {
        return tenantCodeLike;
    }

    /** 设置租户编号模糊查询条件 **/
    public void setTenantCodeLike(String tenantCodeLike) {
        this.tenantCodeLike = tenantCodeLike;
    }

    /** 判断数据类型是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getDataTypeIsNull() {
        return dataTypeIsNull;
    }

    /**
     * 设置数据类型空值查询(true:空值查询|false:非空值查询)
     *
     * @param dataTypeIsNull 数据类型空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setDataTypeIsNull(Boolean dataTypeIsNull) {
        this.dataTypeIsNull = dataTypeIsNull;
    }

    /** 获取数据类型前模匹配条件 **/
    public String getDataTypeStarts() {
        return dataTypeStarts;
    }

    /** 设置数据类型前模匹配条件 **/
    public void setDataTypeStarts(String dataTypeStarts) {
        this.dataTypeStarts = dataTypeStarts;
    }

    /** 获取数据类型后模匹配条件 **/
    public String getDataTypeEnds() {
        return dataTypeEnds;
    }

    /** 设置数据类型后模匹配条件 **/
    public void setDataTypeEnds(String dataTypeEnds) {
        this.dataTypeEnds = dataTypeEnds;
    }

    /** 获取数据类型模糊查询条件 **/
    public String getDataTypeLike() {
        return dataTypeLike;
    }

    /** 设置数据类型模糊查询条件 **/
    public void setDataTypeLike(String dataTypeLike) {
        this.dataTypeLike = dataTypeLike;
    }

    /** 判断数据ID是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getDataIdIsNull() {
        return dataIdIsNull;
    }

    /**
     * 设置数据ID空值查询(true:空值查询|false:非空值查询)
     *
     * @param dataIdIsNull 数据ID空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setDataIdIsNull(Boolean dataIdIsNull) {
        this.dataIdIsNull = dataIdIsNull;
    }

    /** 获取数据ID前模匹配条件 **/
    public String getDataIdStarts() {
        return dataIdStarts;
    }

    /** 设置数据ID前模匹配条件 **/
    public void setDataIdStarts(String dataIdStarts) {
        this.dataIdStarts = dataIdStarts;
    }

    /** 获取数据ID后模匹配条件 **/
    public String getDataIdEnds() {
        return dataIdEnds;
    }

    /** 设置数据ID后模匹配条件 **/
    public void setDataIdEnds(String dataIdEnds) {
        this.dataIdEnds = dataIdEnds;
    }

    /** 获取数据ID模糊查询条件 **/
    public String getDataIdLike() {
        return dataIdLike;
    }

    /** 设置数据ID模糊查询条件 **/
    public void setDataIdLike(String dataIdLike) {
        this.dataIdLike = dataIdLike;
    }

    /** 判断数据描述是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getDataDescIsNull() {
        return dataDescIsNull;
    }

    /** 设置数据描述空值查询(true:空值查询|false:非空值查询) **/
    public void setDataDescIsNull(Boolean dataDescIsNull) {
        this.dataDescIsNull = dataDescIsNull;
    }

    /** 获取数据描述前模匹配条件 **/
    public String getDataDescStarts() {
        return dataDescStarts;
    }

    /** 设置数据描述前模匹配条件 **/
    public void setDataDescStarts(String dataDescStarts) {
        this.dataDescStarts = dataDescStarts;
    }

    /** 获取数据描述后模匹配条件 **/
    public String getDataDescEnds() {
        return dataDescEnds;
    }

    /** 设置数据描述后模匹配条件 **/
    public void setDataDescEnds(String dataDescEnds) {
        this.dataDescEnds = dataDescEnds;
    }

    /** 获取数据描述模糊查询条件 **/
    public String getDataDescLike() {
        return dataDescLike;
    }

    /** 设置数据描述模糊查询条件 **/
    public void setDataDescLike(String dataDescLike) {
        this.dataDescLike = dataDescLike;
    }

    /** 判断业务类型是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getBizTypeIsNull() {
        return bizTypeIsNull;
    }

    /** 设置业务类型空值查询(true:空值查询|false:非空值查询) **/
    public void setBizTypeIsNull(Boolean bizTypeIsNull) {
        this.bizTypeIsNull = bizTypeIsNull;
    }

    /** 获取业务类型前模匹配条件 **/
    public String getBizTypeStarts() {
        return bizTypeStarts;
    }

    /** 设置业务类型前模匹配条件 **/
    public void setBizTypeStarts(String bizTypeStarts) {
        this.bizTypeStarts = bizTypeStarts;
    }

    /** 获取业务类型后模匹配条件 **/
    public String getBizTypeEnds() {
        return bizTypeEnds;
    }

    /** 设置业务类型后模匹配条件 **/
    public void setBizTypeEnds(String bizTypeEnds) {
        this.bizTypeEnds = bizTypeEnds;
    }

    /** 获取业务类型模糊查询条件 **/
    public String getBizTypeLike() {
        return bizTypeLike;
    }

    /** 设置业务类型模糊查询条件 **/
    public void setBizTypeLike(String bizTypeLike) {
        this.bizTypeLike = bizTypeLike;
    }

    /** 判断业务编号是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getBizCodeIsNull() {
        return bizCodeIsNull;
    }

    /** 设置业务编号空值查询(true:空值查询|false:非空值查询) **/
    public void setBizCodeIsNull(Boolean bizCodeIsNull) {
        this.bizCodeIsNull = bizCodeIsNull;
    }

    /** 获取业务编号前模匹配条件 **/
    public String getBizCodeStarts() {
        return bizCodeStarts;
    }

    /** 设置业务编号前模匹配条件 **/
    public void setBizCodeStarts(String bizCodeStarts) {
        this.bizCodeStarts = bizCodeStarts;
    }

    /** 获取业务编号后模匹配条件 **/
    public String getBizCodeEnds() {
        return bizCodeEnds;
    }

    /** 设置业务编号后模匹配条件 **/
    public void setBizCodeEnds(String bizCodeEnds) {
        this.bizCodeEnds = bizCodeEnds;
    }

    /** 获取业务编号模糊查询条件 **/
    public String getBizCodeLike() {
        return bizCodeLike;
    }

    /** 设置业务编号模糊查询条件 **/
    public void setBizCodeLike(String bizCodeLike) {
        this.bizCodeLike = bizCodeLike;
    }

    /** 判断可见级别:1.用户可见|2.管理员可见|3.高管可见是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getVisibleLevelIsNull() {
        return visibleLevelIsNull;
    }

    /**
     * 设置可见级别:1.用户可见|2.管理员可见|3.高管可见空值查询(true:空值查询|false:非空值查询)
     *
     * @param visibleLevelIsNull 可见级别:1.用户可见|2.管理员可见|3.高管可见空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setVisibleLevelIsNull(Boolean visibleLevelIsNull) {
        this.visibleLevelIsNull = visibleLevelIsNull;
    }

    /** 获取最小可见级别:1.用户可见|2.管理员可见|3.高管可见 **/
    public Integer getVisibleLevelMin() {
        return visibleLevelMin;
    }

    /** 设置最小可见级别:1.用户可见|2.管理员可见|3.高管可见 **/
    public void setVisibleLevelMin(Integer visibleLevelMin) {
        this.visibleLevelMin = visibleLevelMin;
    }

    /** 获取最大可见级别:1.用户可见|2.管理员可见|3.高管可见 **/
    public Integer getVisibleLevelMax() {
        return visibleLevelMax;
    }

    /** 设置最大可见级别:1.用户可见|2.管理员可见|3.高管可见 **/
    public void setVisibleLevelMax(Integer visibleLevelMax) {
        this.visibleLevelMax = visibleLevelMax;
    }

    /** 判断处理类型(0.处理|1.备注|2.结论)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getProcessTypeIsNull() {
        return processTypeIsNull;
    }

    /** 设置处理类型(0.处理|1.备注|2.结论)空值查询(true:空值查询|false:非空值查询) **/
    public void setProcessTypeIsNull(Boolean processTypeIsNull) {
        this.processTypeIsNull = processTypeIsNull;
    }

    /** 获取处理类型(0.处理|1.备注|2.结论)列表 **/
    public List<ProcessType> getProcessTypes() {
        return processTypes;
    }

    /** 设置处理类型(0.处理|1.备注|2.结论)列表 **/
    public void setProcessTypes(List<ProcessType> processTypes) {
        this.processTypes = processTypes;
    }

    /** 增加处理类型(0.处理|1.备注|2.结论) **/
    public void addProcessType(ProcessType... processTypes) {
        if (this.processTypes == null) {
            this.processTypes = new ArrayList<>();
        }
        this.processTypes.addAll(Arrays.asList(processTypes));
    }

    /** 判断处理标题是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getProcessTitleIsNull() {
        return processTitleIsNull;
    }

    /** 设置处理标题空值查询(true:空值查询|false:非空值查询) **/
    public void setProcessTitleIsNull(Boolean processTitleIsNull) {
        this.processTitleIsNull = processTitleIsNull;
    }

    /** 获取处理标题前模匹配条件 **/
    public String getProcessTitleStarts() {
        return processTitleStarts;
    }

    /** 设置处理标题前模匹配条件 **/
    public void setProcessTitleStarts(String processTitleStarts) {
        this.processTitleStarts = processTitleStarts;
    }

    /** 获取处理标题后模匹配条件 **/
    public String getProcessTitleEnds() {
        return processTitleEnds;
    }

    /** 设置处理标题后模匹配条件 **/
    public void setProcessTitleEnds(String processTitleEnds) {
        this.processTitleEnds = processTitleEnds;
    }

    /** 获取处理标题模糊查询条件 **/
    public String getProcessTitleLike() {
        return processTitleLike;
    }

    /** 设置处理标题模糊查询条件 **/
    public void setProcessTitleLike(String processTitleLike) {
        this.processTitleLike = processTitleLike;
    }

    /** 判断处理描述是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getProcessContentIsNull() {
        return processContentIsNull;
    }

    /** 设置处理描述空值查询(true:空值查询|false:非空值查询) **/
    public void setProcessContentIsNull(Boolean processContentIsNull) {
        this.processContentIsNull = processContentIsNull;
    }

    /** 获取处理描述前模匹配条件 **/
    public String getProcessContentStarts() {
        return processContentStarts;
    }

    /** 设置处理描述前模匹配条件 **/
    public void setProcessContentStarts(String processContentStarts) {
        this.processContentStarts = processContentStarts;
    }

    /** 获取处理描述后模匹配条件 **/
    public String getProcessContentEnds() {
        return processContentEnds;
    }

    /** 设置处理描述后模匹配条件 **/
    public void setProcessContentEnds(String processContentEnds) {
        this.processContentEnds = processContentEnds;
    }

    /** 获取处理描述模糊查询条件 **/
    public String getProcessContentLike() {
        return processContentLike;
    }

    /** 设置处理描述模糊查询条件 **/
    public void setProcessContentLike(String processContentLike) {
        this.processContentLike = processContentLike;
    }

    /** 判断处理状态(文字)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getProcessStateIsNull() {
        return processStateIsNull;
    }

    /** 设置处理状态(文字)空值查询(true:空值查询|false:非空值查询) **/
    public void setProcessStateIsNull(Boolean processStateIsNull) {
        this.processStateIsNull = processStateIsNull;
    }

    /** 获取处理状态(文字)前模匹配条件 **/
    public String getProcessStateStarts() {
        return processStateStarts;
    }

    /** 设置处理状态(文字)前模匹配条件 **/
    public void setProcessStateStarts(String processStateStarts) {
        this.processStateStarts = processStateStarts;
    }

    /** 获取处理状态(文字)后模匹配条件 **/
    public String getProcessStateEnds() {
        return processStateEnds;
    }

    /** 设置处理状态(文字)后模匹配条件 **/
    public void setProcessStateEnds(String processStateEnds) {
        this.processStateEnds = processStateEnds;
    }

    /** 获取处理状态(文字)模糊查询条件 **/
    public String getProcessStateLike() {
        return processStateLike;
    }

    /** 设置处理状态(文字)模糊查询条件 **/
    public void setProcessStateLike(String processStateLike) {
        this.processStateLike = processStateLike;
    }

    /** 判断处理人id是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getProcessorIdIsNull() {
        return processorIdIsNull;
    }

    /**
     * 设置处理人id空值查询(true:空值查询|false:非空值查询)
     *
     * @param processorIdIsNull 处理人id空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setProcessorIdIsNull(Boolean processorIdIsNull) {
        this.processorIdIsNull = processorIdIsNull;
    }

    /** 获取处理人id前模匹配条件 **/
    public String getProcessorIdStarts() {
        return processorIdStarts;
    }

    /** 设置处理人id前模匹配条件 **/
    public void setProcessorIdStarts(String processorIdStarts) {
        this.processorIdStarts = processorIdStarts;
    }

    /** 获取处理人id后模匹配条件 **/
    public String getProcessorIdEnds() {
        return processorIdEnds;
    }

    /** 设置处理人id后模匹配条件 **/
    public void setProcessorIdEnds(String processorIdEnds) {
        this.processorIdEnds = processorIdEnds;
    }

    /** 获取处理人id模糊查询条件 **/
    public String getProcessorIdLike() {
        return processorIdLike;
    }

    /** 设置处理人id模糊查询条件 **/
    public void setProcessorIdLike(String processorIdLike) {
        this.processorIdLike = processorIdLike;
    }

    /** 判断处理人姓名是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getProcessorNameIsNull() {
        return processorNameIsNull;
    }

    /**
     * 设置处理人姓名空值查询(true:空值查询|false:非空值查询)
     *
     * @param processorNameIsNull 处理人姓名空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setProcessorNameIsNull(Boolean processorNameIsNull) {
        this.processorNameIsNull = processorNameIsNull;
    }

    /** 获取处理人姓名前模匹配条件 **/
    public String getProcessorNameStarts() {
        return processorNameStarts;
    }

    /** 设置处理人姓名前模匹配条件 **/
    public void setProcessorNameStarts(String processorNameStarts) {
        this.processorNameStarts = processorNameStarts;
    }

    /** 获取处理人姓名后模匹配条件 **/
    public String getProcessorNameEnds() {
        return processorNameEnds;
    }

    /** 设置处理人姓名后模匹配条件 **/
    public void setProcessorNameEnds(String processorNameEnds) {
        this.processorNameEnds = processorNameEnds;
    }

    /** 获取处理人姓名模糊查询条件 **/
    public String getProcessorNameLike() {
        return processorNameLike;
    }

    /** 设置处理人姓名模糊查询条件 **/
    public void setProcessorNameLike(String processorNameLike) {
        this.processorNameLike = processorNameLike;
    }

    /** 判断处理时间是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getProcessTimeIsNull() {
        return processTimeIsNull;
    }

    /**
     * 设置处理时间空值查询(true:空值查询|false:非空值查询)
     *
     * @param processTimeIsNull 处理时间空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setProcessTimeIsNull(Boolean processTimeIsNull) {
        this.processTimeIsNull = processTimeIsNull;
    }

    /** 获取最小处理时间 **/
    public Date getProcessTimeMin() {
        return processTimeMin;
    }

    /** 设置最小处理时间 **/
    public void setProcessTimeMin(Date processTimeMin) {
        this.processTimeMin = processTimeMin;
    }

    /** 获取最大处理时间 **/
    public Date getProcessTimeMax() {
        return processTimeMax;
    }

    /** 设置最大处理时间 **/
    public void setProcessTimeMax(Date processTimeMax) {
        this.processTimeMax = processTimeMax;
    }

    /** 获取最小处理时间 **/
    public Date getProcessTimeMinWithDay() {
        return processTimeMinWithDay;
    }

    /** 设置最小处理时间 **/
    public void setProcessTimeMinWithDay(Date processTimeMinWithDay) {
        this.processTimeMinWithDay = processTimeMinWithDay;
    }

    /** 获取最大处理时间 **/
    public Date getProcessTimeMaxWithDay() {
        return processTimeMaxWithDay;
    }

    /** 设置最大处理时间 **/
    public void setProcessTimeMaxWithDay(Date processTimeMaxWithDay) {
        this.processTimeMaxWithDay = processTimeMaxWithDay;
    }

    /** 判断查询字符串是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getQueryStringIsNull() {
        return queryStringIsNull;
    }

    /** 设置查询字符串空值查询(true:空值查询|false:非空值查询) **/
    public void setQueryStringIsNull(Boolean queryStringIsNull) {
        this.queryStringIsNull = queryStringIsNull;
    }

    /** 获取查询字符串前模匹配条件 **/
    public String getQueryStringStarts() {
        return queryStringStarts;
    }

    /** 设置查询字符串前模匹配条件 **/
    public void setQueryStringStarts(String queryStringStarts) {
        this.queryStringStarts = queryStringStarts;
    }

    /** 获取查询字符串后模匹配条件 **/
    public String getQueryStringEnds() {
        return queryStringEnds;
    }

    /** 设置查询字符串后模匹配条件 **/
    public void setQueryStringEnds(String queryStringEnds) {
        this.queryStringEnds = queryStringEnds;
    }

    /** 获取查询字符串模糊查询条件 **/
    public String getQueryStringLike() {
        return queryStringLike;
    }

    /** 设置查询字符串模糊查询条件 **/
    public void setQueryStringLike(String queryStringLike) {
        this.queryStringLike = queryStringLike;
    }

    /** 判断选项是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getOptionsIsNull() {
        return optionsIsNull;
    }

    /** 设置选项空值查询(true:空值查询|false:非空值查询) **/
    public void setOptionsIsNull(Boolean optionsIsNull) {
        this.optionsIsNull = optionsIsNull;
    }

}